home *** CD-ROM | disk | FTP | other *** search
/ System Booster / System Booster.iso / Commodities / RunList3 / RunList3i / src / RunList3i.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-09-27  |  21.4 KB  |  806 lines
  1. /*
  2.  *  Source machine generated by GadToolsBox V2.0b
  3.  *  which is (c) Copyright 1991-1993 Jaba Development
  4.  *
  5.  *  GUI Designed by : -- Heinz Reinert --
  6.  */
  7.  
  8. #include <exec/types.h>
  9. #include <intuition/intuition.h>
  10. #include <intuition/classes.h>
  11. #include <intuition/classusr.h>
  12. #include <intuition/imageclass.h>
  13. #include <intuition/gadgetclass.h>
  14. #include <libraries/gadtools.h>
  15. #include <graphics/displayinfo.h>
  16. #include <graphics/gfxbase.h>
  17. #include <clib/exec_protos.h>
  18. #include <clib/intuition_protos.h>
  19. #include <clib/gadtools_protos.h>
  20. #include <clib/graphics_protos.h>
  21. #include <clib/utility_protos.h>
  22. #include <proto/intuition.h>
  23. #include <proto/graphics.h>
  24. #include <proto/exec.h>
  25. #include <proto/dos.h>
  26. #include <proto/gadtools.h>
  27. #include <exec/memory.h>
  28. #include <string.h>
  29.  
  30.                                       
  31.  
  32. #define GetString( g )      ((( struct StringInfo * )g->SpecialInfo )->Buffer  )
  33. #define GetNumber( g )      ((( struct StringInfo * )g->SpecialInfo )->LongInt )
  34.  
  35. #define GD_list                                0
  36. #define GD_new                                 1
  37. #define GD_del                                 2
  38. #define GD_descr                               3
  39. #define GD_command1                            4
  40. #define GD_command2                            5
  41. #define GD_command3                            6
  42. #define GD_save                                7
  43. #define GD_runa                                8
  44. #define GD_run3                                9
  45. #define GD_run2                                10
  46. #define GD_run1                                11
  47.  
  48. #define GDX_list                               0
  49. #define GDX_new                                1
  50. #define GDX_del                                2
  51. #define GDX_descr                              3
  52. #define GDX_command1                           4
  53. #define GDX_command2                           5
  54. #define GDX_command3                           6
  55. #define GDX_save                               7
  56. #define GDX_runa                               8
  57. #define GDX_run3                               9
  58. #define GDX_run2                               10
  59. #define GDX_run1                               11
  60.  
  61. #define Project0_CNT 12
  62. UBYTE *vers = "\0$VER: RunList 3";
  63.  
  64. extern struct IntuitionBase *IntuitionBase;
  65. extern struct Library       *GadToolsBase;
  66.  
  67. extern struct Screen        *Scr;
  68. extern UBYTE                 *PubScreenName;
  69. extern APTR                  VisualInfo;
  70. extern struct Window        *Project0Wnd;
  71. extern struct Gadget        *Project0GList;
  72. extern struct Gadget        *Project0Gadgets[12];
  73. extern UWORD                 Project0Left;
  74. extern UWORD                 Project0Top;
  75. extern UWORD                 Project0Width;
  76. extern UWORD                 Project0Height;
  77. extern UBYTE                *Project0Wdt;
  78. extern struct TextAttr       topaz11;
  79. extern UWORD                 Project0GTypes[];
  80. extern struct NewGadget      Project0NGad[];
  81. extern ULONG                 Project0GTags[];
  82.  
  83. extern int SetupScreen( void );
  84. extern void CloseDownScreen( void );
  85. extern int OpenProject0Window( void );
  86. extern void CloseProject0Window( void );
  87.  
  88.  
  89. struct Screen         *Scr = NULL;
  90. UBYTE                 *PubScreenName = NULL;
  91. APTR                   VisualInfo = NULL;
  92. struct Window         *Project0Wnd = NULL;
  93. struct Gadget         *Project0GList = NULL;
  94. struct Gadget         *Project0Gadgets[12];
  95. UWORD                  Project0Left = 330;
  96. UWORD                  Project0Top = 10;
  97. UWORD                  Project0Width = 314;
  98. UWORD                  Project0Height = 0;
  99. UBYTE                 *Project0Wdt = (UBYTE *)"RunList i 3";
  100.  
  101. struct TextAttr topaz11 = {
  102.                  ( STRPTR )"topaz.font", 11, 0x00, 0x01 };
  103.  
  104. UWORD Project0GTypes[] = {
  105.         LISTVIEW_KIND,
  106.         BUTTON_KIND,
  107.         BUTTON_KIND,
  108.         STRING_KIND,
  109.         STRING_KIND,
  110.         STRING_KIND,
  111.         STRING_KIND,
  112.         BUTTON_KIND,
  113.         BUTTON_KIND,
  114.         BUTTON_KIND,
  115.         BUTTON_KIND,
  116.         BUTTON_KIND
  117. };
  118.  
  119. struct NewGadget Project0NGad[] = {
  120.         8, 10, 198, 360, NULL, NULL, GD_list, 0, NULL, NULL,
  121.         212, 10, 72, 25, (UBYTE *)"NEW", NULL, GD_new, PLACETEXT_IN, NULL, NULL,
  122.         212, 35, 72, 25, (UBYTE *)"DELETE", NULL, GD_del, PLACETEXT_IN, NULL, NULL,
  123.         8, 366, 198, 19, NULL, NULL, GD_descr, 0, NULL, NULL,
  124.         8, 392, 277, 19, NULL, NULL, GD_command1, 0, NULL, NULL,
  125.         8, 412, 277, 19, NULL, NULL, GD_command2, 0, NULL, NULL,
  126.         8, 432, 277, 19, NULL, NULL, GD_command3, 0, NULL, NULL,
  127.         212, 60, 72, 25, (UBYTE *)"SAVE", NULL, GD_save, PLACETEXT_IN, NULL, NULL,
  128.         212, 85, 72, 225, (UBYTE *)"RUN ALL", NULL, GD_runa, PLACETEXT_IN, NULL, NULL,
  129.         212, 360, 72, 25, (UBYTE *)"RUN 3", NULL, GD_run3, PLACETEXT_IN, NULL, NULL,
  130.         212, 335, 72, 25, (UBYTE *)"RUN 2", NULL, GD_run2, PLACETEXT_IN, NULL, NULL,
  131.         212, 310, 72, 25, (UBYTE *)"RUN 1", NULL, GD_run1, PLACETEXT_IN, NULL, NULL
  132. };
  133.  
  134. ULONG Project0GTags[] = {
  135.         (TAG_DONE),
  136.         (TAG_DONE),
  137.         (TAG_DONE),
  138.         (GTST_MaxChars), 256, (TAG_DONE),
  139.         (GTST_MaxChars), 256, (TAG_DONE),
  140.         (GTST_MaxChars), 256, (TAG_DONE),
  141.         (GTST_MaxChars), 256, (TAG_DONE),
  142.         (TAG_DONE),
  143.         (TAG_DONE),
  144.         (TAG_DONE),
  145.         (TAG_DONE),
  146.         (TAG_DONE)
  147. };
  148.  
  149. int SetupScreen( void )
  150. {
  151.         if ( ! ( Scr = LockPubScreen( PubScreenName )))
  152.                 return( 1L );
  153.  
  154.         if ( ! ( VisualInfo = GetVisualInfo( Scr, TAG_DONE )))
  155.                 return( 2L );
  156.  
  157.         return( 0L );
  158. }
  159.  
  160. void CloseDownScreen( void )
  161. {
  162.         if ( VisualInfo ) {
  163.                 FreeVisualInfo( VisualInfo );
  164.                 VisualInfo = NULL;
  165.         }
  166.  
  167.         if ( Scr        ) {
  168.                 UnlockPubScreen( NULL, Scr );
  169.                 Scr = NULL;
  170.         }
  171. }
  172.  
  173. int OpenProject0Window( void )
  174. {
  175.         struct NewGadget        ng;
  176.         struct Gadget   *g;
  177.         UWORD           lc, tc;
  178.         UWORD           offx = Scr->WBorLeft, offy = Scr->WBorTop + Scr->RastPort.TxHeight + 1;
  179.  
  180.         if ( ! ( g = CreateContext( &Project0GList )))
  181.                 return( 1L );
  182.  
  183.         for( lc = 0, tc = 0; lc < Project0_CNT; lc++ ) {
  184.  
  185.                 CopyMem((char * )&Project0NGad[ lc ], (char * )&ng, (long)sizeof( struct NewGadget ));
  186.  
  187.                 ng.ng_VisualInfo = VisualInfo;
  188.                 ng.ng_TextAttr   = &topaz11;
  189.                 ng.ng_LeftEdge  += offx;
  190.                 ng.ng_TopEdge   += offy;
  191.  
  192.                 Project0Gadgets[ lc ] = g = CreateGadgetA((ULONG)Project0GTypes[ lc ], g, &ng, ( struct TagItem * )&Project0GTags[ tc ] );
  193.  
  194.                 while( Project0GTags[ tc ] ) tc += 2;
  195.                 tc++;
  196.  
  197.                 if ( NOT g )
  198.                         return( 2L );
  199.         }
  200.  
  201.  
  202.         if ( ! ( Project0Wnd = OpenWindowTags( NULL,
  203.                                 WA_Left,        Project0Left,
  204.                                 WA_Top,         Project0Top,
  205.                                 WA_Width,       Project0Width,
  206.                                 WA_Height,      Project0Height + offy,
  207.                                 WA_IDCMP,       LISTVIEWIDCMP|
  208.                                                 BUTTONIDCMP|
  209.                                                 STRINGIDCMP|
  210.                                                 IDCMP_NEWSIZE|
  211.                                                 IDCMP_CLOSEWINDOW|
  212.                                                 IDCMP_CHANGEWINDOW|
  213.                                                 IDCMP_INTUITICKS |
  214.                                                 IDCMP_MOUSEBUTTONS|
  215.                                                 IDCMP_REFRESHWINDOW,
  216.                                 WA_Flags,       WFLG_SIZEGADGET|
  217.                                                 WFLG_DRAGBAR|
  218.                                                 WFLG_DEPTHGADGET|
  219.                                                 WFLG_CLOSEGADGET|
  220.                                                 WFLG_SMART_REFRESH,
  221.                                 WA_Gadgets,     Project0GList,
  222.                                 WA_Title,       Project0Wdt,
  223.                                 WA_ScreenTitle, "RunList i 3 © Heinz Reinert 1995",
  224.                                 WA_PubScreen,   Scr,
  225.                                 WA_MinWidth,    314,
  226.                                 WA_MinHeight,   472,
  227.                                 WA_MaxWidth,    314,
  228.                                 WA_MaxHeight,   472,
  229.                                 TAG_DONE )))
  230.         return( 4L );
  231.  
  232.         GT_RefreshWindow( Project0Wnd, NULL );
  233.  
  234.         return( 0L );
  235. }
  236.  
  237. void CloseProject0Window( void )
  238. {
  239.         if ( Project0Wnd        ) {
  240.                 CloseWindow( Project0Wnd );
  241.                 Project0Wnd = NULL;
  242.         }
  243.  
  244.         if ( Project0GList      ) {
  245.                 FreeGadgets( Project0GList );
  246.                 Project0GList = NULL;
  247.         }
  248. }
  249.  
  250. /*
  251.  * Struktur für einen Datenbankeintrag
  252.  */
  253.  
  254. struct VDB {
  255.     char    Name[30];
  256.     char    list[256];
  257.     USHORT  new;
  258.     USHORT  del;
  259.     char    command1[81], command2[81], command3[81];
  260.     USHORT  save;
  261.     USHORT  runa;
  262.     USHORT  run3;
  263.     USHORT  run2;
  264.     USHORT  run1;
  265.                             
  266. };
  267.  
  268.  
  269.  
  270. struct VDBnode {
  271.         struct  Node n; /*** Für Liste    ***/
  272.         struct  VDB d;  /*** VDB-Struktur ***/
  273. };
  274.  
  275. /*
  276.  * Flags
  277.  */
  278.  
  279. #define VDBF_STEREO             1
  280.  
  281. /*
  282.  *
  283.  * In dieser Liste befinden sich die VDB-Nodes
  284.  *
  285.  */
  286.  
  287. struct List vdblist;
  288.  
  289. /*
  290.  * Der aktuelle Eintrag
  291.  */
  292.  
  293. struct VDBnode *currentprj;
  294.  
  295. /*
  296.  * Die von der Gadtoolsbox erzeugten Header
  297.  */
  298.  
  299.  
  300. /*
  301.  *
  302.  * Die Hilfsroutinen
  303.  *
  304.  */
  305.  
  306. /*
  307.  * Allgemeine Gadgets
  308.  */
  309.  
  310. /*
  311.  *      Gadtools-Gadget einschalten
  312.  */
  313. void gt_OnGadget( struct Gadget         *gad,
  314.                                   struct Window         *w )
  315. {
  316.         GT_SetGadgetAttrs( gad, w, NULL, GA_DISABLED, FALSE, TAG_DONE );
  317. }
  318. /*
  319.  *      ...und wieder aus...
  320.  */
  321. void gt_OffGadget( struct Gadget        *gad,
  322.                                    struct Window        *w )
  323. {
  324.         GT_SetGadgetAttrs( gad, w, NULL, GA_DISABLED, TRUE, TAG_DONE );
  325. }
  326.  
  327.  
  328. /*
  329.  *  String-Gadgets
  330.  */
  331. void gt_SetString( struct Gadget        *gad,
  332.                                    struct Window        *w,
  333.                                    char                         *string )
  334. {
  335.         GT_SetGadgetAttrs( gad, w, NULL, GTST_String, string, TAG_DONE );
  336. }
  337.  
  338. char * gt_GetString( struct Gadget      *gad )
  339. {
  340.         struct StringInfo *si = gad->SpecialInfo;
  341.  
  342.         if( si )
  343.                 return( ( char * ) si->Buffer );
  344.         else
  345.                 return( NULL );
  346. }
  347.  
  348. /*
  349.  * Listenverwaltung für Listview-Gadgets
  350.  */
  351.  
  352. /*
  353.  * Liste anhängen
  354.  * "list" kann ~0 (-1) sein, dann ist kein Listenzugriff möglich
  355.  */
  356.  
  357. void gt_AttachList(     struct Gadget   *lv,
  358.                                         struct Window   *w,
  359.                                         struct List     *list )
  360. {
  361.         GT_SetGadgetAttrs( lv, w, NULL, GTLV_Labels, list, TAG_DONE );
  362. }
  363.  
  364. /*
  365.  *  Aktuellen Eintrag setzen
  366.  */
  367. void gt_SetLV( struct Gadget    *gad,
  368.                            struct Window        *w,
  369.                            ULONG                        value)
  370. {
  371.         GT_SetGadgetAttrs( gad, w, NULL, GTLV_Selected, value, TAG_DONE );
  372. }
  373.  
  374. /*
  375.  * x-ten Eintrag aus einer Exec-Liste holen
  376.  */
  377. struct Node * gt_GetListEntry( struct List *l,
  378.                                                            int num )
  379. {
  380.         int count = 0;
  381.         struct Node *n = l->lh_Head;
  382.  
  383.         while( n->ln_Succ )
  384.         {
  385.                 if( num==count ) return( n );
  386.                 n = n->ln_Succ;
  387.                 count++;
  388.         }
  389.         return( NULL );
  390. }
  391. /*
  392.  * Nummer einer Node aus einer Liste feststellen
  393.  * -1 falls nicht in Liste
  394.  */
  395. int gt_GetListEntryNum( struct List *l,
  396.                                                 struct Node *n )
  397. {
  398.         int count = 0;
  399.         struct Node *r = l->lh_Head;
  400.  
  401.         while( r->ln_Succ )
  402.         {
  403.                 if( r==n ) return( count );
  404.                 r = r->ln_Succ;
  405.                 count++;
  406.         }
  407.         return( -1 );
  408. }
  409. /*
  410.  * Anzahl Einträge einer Liste zählen
  411.  */
  412. int gt_GetListNumEntries( struct List *l )
  413. {
  414.         int count = 0;
  415.         struct Node *n = l->lh_Head;
  416.  
  417.         while( n->ln_Succ )
  418.         {
  419.                 n = n->ln_Succ;
  420.                 count++;
  421.         }
  422.  
  423.         return( count );
  424. }
  425.  
  426. /************************************************************************/
  427.  
  428. /*
  429.  *
  430.  *  Liste laden
  431.  *
  432.  */
  433.  
  434. void loadprjlist( void )
  435. {
  436.         struct VDB new;
  437.         struct VDBnode *n;
  438.         BPTR f;
  439.  
  440.         /*** Liste initialisieren ***/
  441.         NewList( &vdblist );
  442.         currentprj = NULL;
  443.  
  444.         /*** Datei öffnen ***/
  445.         f = Open( "S:List.DAT", MODE_OLDFILE );
  446.         if( !f )
  447.                 return;
  448.  
  449.         /*** Einträge einlesen */
  450.         while( Read( f, &new, sizeof( new ) ) == sizeof( new ) )
  451.         {
  452.                 /*** newe Node ***/
  453.                 n = AllocVec( sizeof( *n ), 0 );
  454.                 if( !n )
  455.                         break;
  456.  
  457.                 /*** Struktur kopieren und an Liste anhängen ***/
  458.                 n->d = new;
  459.                 n->n.ln_Name = n->d.Name;
  460.                 n->n.ln_Pri      = - n->d.Name[0];
  461.                 Enqueue( &vdblist, (struct Node *) n );
  462.         }
  463.  
  464.         Close( f );
  465. }
  466.  
  467. /*
  468.  *      Liste speichern und freigeben 
  469.  */
  470.  
  471. void save_and_freeprjlist(void )
  472. {
  473.         struct VDBnode *n;
  474.         BPTR f;
  475.  
  476.         f = Open( "S:List.DAT", MODE_NEWFILE );
  477.  
  478.         while( ( n = (struct VDBnode * ) RemHead( &vdblist ) ) )
  479.         {
  480.                 /*** Node speichern... ***/
  481.                 if( f )
  482.                         Write( f, &n->d, sizeof( struct VDB ) );
  483.  
  484.                 /*** ...und freigeben ***/
  485.                 FreeVec( n );
  486.         }
  487.  
  488.         if( f )
  489.                 Close( f );
  490. }
  491.  
  492.  
  493. /************************************************************************/
  494.  
  495. /*
  496.  * Schaltet die Gadgets mit Ausnahme der Liste ein oder aus
  497.  * abhängig davon, ob gerade ein Listeneintrag aktiviert ist
  498.  * oder nicht
  499.  *
  500.  */
  501.  
  502. void checkonoff( void )
  503. {
  504.         int c;
  505.  
  506.         if( currentprj )
  507.         {
  508.                 for( c = GD_del; c < Project0_CNT; c++ )
  509.                         gt_OnGadget( Project0Gadgets[c], Project0Wnd );
  510.         }
  511.         else
  512.         {
  513.                 for( c = GD_del; c < Project0_CNT; c++ )
  514.                         gt_OffGadget( Project0Gadgets[c], Project0Wnd );
  515.         }
  516.  
  517. }
  518.  
  519. /*
  520.  *
  521.  *  Trägt die Werte aus der aktuellen Struktur in die
  522.  *  Gadgets ein
  523.  *
  524.  */
  525.  
  526. void setgadvals( void )
  527. {
  528.  
  529.         if( !currentprj )
  530.                 return;
  531.  
  532.         gt_SetString(   Project0Gadgets[ GD_descr ], Project0Wnd,
  533.                                                    currentprj->d.Name );
  534.         gt_SetString(   Project0Gadgets[ GD_command1 ], Project0Wnd,
  535.                                                    currentprj->d.command1 );
  536.         gt_SetString(   Project0Gadgets[ GD_command2 ], Project0Wnd,
  537.                                                    currentprj->d.command2 );
  538.         gt_SetString(   Project0Gadgets[ GD_command3 ], Project0Wnd,
  539.                                                    currentprj->d.command3 );
  540.  
  541.  
  542. }
  543.  
  544.  
  545. /*
  546.  *
  547.  *  Erzeugt einen neuen, leeren Eintrag 
  548.  *
  549.  */
  550.  
  551. void newvdb( void )
  552. {
  553.         struct VDBnode *new;
  554.  
  555.         new = AllocVec( sizeof( *new ), MEMF_CLEAR );
  556.  
  557.         if( !new )
  558.                 return;
  559.  
  560.         currentprj = new;
  561.  
  562.         new->n.ln_Name = new->d.Name;
  563.  
  564.         strcpy( new->d.Name, "new" );
  565.  
  566.         gt_AttachList( Project0Gadgets[GD_list], Project0Wnd, (struct List *) ~0 );
  567.  
  568.         new->n.ln_Pri    = - new->d.Name[0];
  569.         Enqueue( &vdblist, (struct Node *) new );
  570.  
  571.         gt_AttachList( Project0Gadgets[GD_list], Project0Wnd, &vdblist );
  572.  
  573.         gt_SetLV( Project0Gadgets[GD_list], Project0Wnd, gt_GetListEntryNum( &vdblist, new ) );
  574.         checkonoff();
  575.         setgadvals();
  576. }
  577.  
  578.  
  579.  
  580. /*
  581.  *      Gadget-Event bearbeiten
  582.  */
  583.  
  584. void dogadup( struct IntuiMessage *im )
  585. {
  586.         struct Gadget *g = im->IAddress;
  587.  
  588.         switch( g->GadgetID )
  589.         {
  590.  
  591. /*** Ein Listeneintrag ***/
  592. case GD_list:
  593.         currentprj = (struct VDBnode *) gt_GetListEntry( &vdblist, im->Code );
  594.         checkonoff();
  595.         setgadvals();
  596.         break;
  597.  
  598. /*** new ***/
  599. case GD_new:
  600.         newvdb();
  601.         break;
  602.  
  603. /*** Löschen ***/
  604. case GD_del:
  605.         if( currentprj )
  606.         {
  607.                 gt_AttachList( Project0Gadgets[ GD_list ], Project0Wnd, (struct List *) ~0 );
  608.                 Remove( currentprj );
  609.                 FreeVec( currentprj );
  610.                 currentprj = FALSE;
  611.                 checkonoff();
  612.                 gt_AttachList( Project0Gadgets[ GD_list ], Project0Wnd, &vdblist );
  613.                 gt_SetLV( Project0Gadgets[ GD_list ], Project0Wnd, ~0 );
  614.         }
  615.         break;
  616.  
  617. /*** KassettenName ***/
  618. case GD_descr:
  619.         if( currentprj )
  620.         {
  621.                 gt_AttachList( Project0Gadgets[ GD_list ], Project0Wnd, (struct List *) ~0 );
  622.                 strcpy( currentprj->d.Name, gt_GetString( Project0Gadgets[ GD_descr ] ) );
  623.                 gt_AttachList( Project0Gadgets[ GD_list ], Project0Wnd, &vdblist );
  624.         }
  625.         checkonoff();
  626.         break;
  627.  
  628.  
  629. case GD_command1:
  630.         if( currentprj )
  631.         {
  632.                 strcpy( currentprj->d.command1, gt_GetString( Project0Gadgets[ GD_command1 ] ) );
  633.         }
  634.         checkonoff();
  635.         break;
  636.  
  637. case GD_command2:
  638.         if( currentprj )
  639.         {
  640.                 strcpy( currentprj->d.command2, gt_GetString( Project0Gadgets[ GD_command2 ] ) );
  641.         }
  642.         checkonoff();
  643.         break;
  644.  
  645. case GD_command3:
  646.         if( currentprj )
  647.         {
  648.                strcpy( currentprj->d.command3, gt_GetString( Project0Gadgets[ GD_command3 ] ) );
  649.         }
  650.         checkonoff();
  651.         break;
  652.  
  653. case GD_runa:
  654.         {
  655.             Execute(currentprj->d.command1, NULL, Output());
  656.             Execute(currentprj->d.command2, NULL, Output());
  657.             Execute(currentprj->d.command3, NULL, Output());
  658.         }
  659.         checkonoff();
  660.         break;
  661.  
  662. case GD_run1:
  663.         {
  664.             Execute(currentprj->d.command1, NULL, Output());
  665.         }
  666.         checkonoff();
  667.         break;
  668.  
  669. case GD_run2:
  670.         {
  671.             Execute(currentprj->d.command2, NULL, Output());
  672.         }
  673.         checkonoff();
  674.         break;
  675.  
  676. case GD_run3:
  677.         {
  678.             Execute(currentprj->d.command3, NULL, Output());
  679.         }
  680.         checkonoff();
  681.         break;
  682.  
  683. case GD_save:
  684.         {
  685.             save_and_freeprjlist();
  686.             loadprjlist();
  687.         }
  688.         checkonoff();
  689.         break;
  690.         }
  691. }
  692.  
  693.  
  694. /*
  695.  * Programmstart
  696.  */
  697.  
  698. int main( void )
  699. {
  700.         struct IntuiMessage     *im,imsg;
  701.         BOOL   Done = FALSE;
  702.  
  703.         USHORT code;           /* Code. */
  704.         ULONG seconds, micros; /* Time. */
  705.  
  706.         /* Declare and initialize the time stamps: */
  707.         ULONG sec1 = 0;
  708.         ULONG mic1 = 0;
  709.         ULONG sec2 = 0;
  710.         ULONG mic2 = 0;
  711.  
  712.         /*** Bildschirm und Fenster öffnen ***/
  713.         SetupScreen();
  714.         OpenProject0Window();
  715.  
  716.         /*** Liste laden ***/
  717.         loadprjlist();
  718.  
  719.         /*** Liste anzeigen ***/
  720.         gt_AttachList( Project0Gadgets[GD_list], Project0Wnd, &vdblist );
  721.  
  722.         /*** Gadgets setzen ***/
  723.         checkonoff();
  724.  
  725.         /*** Hauptschleife ***/
  726.         while( !Done )
  727.         {
  728.  
  729.                 /*** Auf IntuiMessage warten ***/
  730.                 while( !( im=GT_GetIMsg( Project0Wnd->UserPort ) ) )
  731.                         WaitPort( Project0Wnd->UserPort );
  732.  
  733.                         code    = im->Code;
  734.                         seconds = im->Seconds;
  735.                         micros  = im->Micros;
  736.  
  737.                 /*** Kopieren ***/
  738.                 imsg = *im;
  739.                 GT_ReplyIMsg( im );             
  740.  
  741.                 switch( imsg.Class )
  742.                 {
  743.  
  744.                         /*** CLOSEWINDOW: Fenster schließen? ***/
  745.                         case IDCMP_CLOSEWINDOW:
  746.                                 Done = TRUE;
  747.                                 break;
  748.  
  749.                         /*** Gadgetup; ein Gadget wurde ausgewählt ***/
  750.                         /*** Wir bearbeiten Gadget-Events in einer ***/
  751.                         /*** eigenen Routine                                       ***/
  752.                         case GADGETUP:
  753.                                 dogadup( &imsg );
  754.                                 break;
  755.  
  756.  
  757.                         case IDCMP_MOUSEBUTTONS: /* The user pressed/released a mouse button. */
  758.                                 if( code == SELECTDOWN )
  759.                                 {
  760.                                    /* Left button pressed. */
  761.  
  762.                                    /* Save the old time: */
  763.                                     sec2 = sec1;
  764.                                     mic2 = mic1;
  765.  
  766.                                    /* Get the new time: */
  767.                                     sec1 = seconds;
  768.                                     mic1 = micros;
  769.  
  770.                                    /* Check if it was a double-click or not: */
  771.                                 if( DoubleClick( sec2, mic2, sec1, mic1 ) )
  772.                                 {
  773.                                     Execute("RUN >NIL: Shellwin ", NULL, Output());
  774.                                    /* Reset the values: */
  775.                                     sec1 = 0;
  776.                                     mic1 = 0;
  777.                                     }
  778.                                 }
  779.                                 break;    
  780.  
  781.  
  782.  
  783.                         /*** REFRESH: Grafikobjekte (Boxen) neu zeichnen ***/
  784.                         case IDCMP_REFRESHWINDOW:
  785.                                 GT_BeginRefresh( Project0Wnd );
  786.                                 GT_EndRefresh( Project0Wnd, TRUE );
  787.                                 break;
  788.  
  789.  
  790.                 }
  791.  
  792.         }
  793.  
  794.         /*** Fenster und Bildschirm wieder schließen ***/       
  795.         CloseProject0Window();
  796.         CloseDownScreen();
  797.  
  798.  
  799.         return(0);
  800. }
  801.     
  802.  
  803.  
  804.   
  805.  
  806.